//数组新方法
//1.扩展运算符...
let arr0 = [1, 2, 3]
console.log([...arr0]) //[ 1, 2, 3 ]

//2.提取数组中的值
console.log(...arr0) //1, 2, 3

//3.将类数组转换为数组(在之前都用的循环push)
//类数组：set数据、arguments、元素组nodeList、字符串等等
let set = new Set(['a', 'b', 'c'])
console.log([...set]) //[ 'a', 'b', 'c' ]

//4.将类数组转换为数组另一种方法Array.from()
let arg = function() {
		return arguments
	},
	str = '字符串'
console.log(Array.from(arg('a', 'b', 'c'))) //[ 'a', 'b', 'c' ]
console.log(Array.from(str)) //[ '字', '符', '串' ]
console.log(str.split('')) //字符串自带方法--[ '字', '符', '串' ]
//用json模拟一个类数组（有length就靠谱）
let json = {
	0: '我',
	1: '爱',
	2: '你',
	length: 3,
}
console.log(Array.from(json)) //[ '我', '爱', '你' ]
console.log([...str]) //[ '字', '符', '串' ]
//console.log([...json])   //报错 json is not iterable

//5.把一组值转换为数组Array.of(),类似于new Array()
console.log(Array.of(1, 2, 3)) //[ 1, 2, 3 ]
console.log(new Array(1, 2, 3)) //[ 1, 2, 3 ]

//6.find()查找，找出第一个符合条件的数组成员,写法类似于forEach()循环
//若没找到返回undefined
let numArr = [1, 2, 3, 4, 5, 6]
let find = numArr.find((item, index, value) => {
	return item > 4
})
console.log(find) //5 

//7.findIndex()查找，找出第一个符合条件的数组成员的下标(位置)
//若没找到返回-1
let numArr2 = [1, 2, 3, 4, 5, 6]
let findIndex = numArr2.findIndex((item, index, value) => {
	return item > 4
})
console.log(findIndex) //4

//8.includes()查找是否包含，和字符串新增的includes()一样
let newArr = [1, 2, 3, 4, 5, 6]
console.log(newArr.includes(0), newArr.includes(1)) //false true

console.log('*********************************************')

/*数组循环方法：取代for循环*/
//forEach()、map()、filter()、some()、every()、reduce()、reduceRight()、find()
//forEach()、map()、filter()、some()、every()中有两个参数，第一个是回调函数，第二个是this(注意箭头函数不能用this获取)
//forEach()、map()、filter()、some()、every()中都是一个回调函数，回调的参数一样
//reduce()、reduceRight()写算法时候用，写的少，基本不用，这里不写
//------------------------------------------------
//1.forEach(function(val,index,arr){...})
let arrr = ['a', 'b', 'c']
arrr.forEach((val, index, arr) => {
	console.log(val, index, arr)
})
//a 0 [ 'a', 'b', 'c' ]
//b 1 [ 'a', 'b', 'c' ]
//c 2 [ 'a', 'b', 'c' ]
arrr.forEach(function(val, index, arr) {
	console.log(this, val, index, arr)
}, 123)
//[Number: 123] 'a' 0 [ 'a', 'b', 'c' ]
//[Number: 123] 'b' 1 [ 'a', 'b', 'c' ]
//[Number: 123] 'c' 2 [ 'a', 'b', 'c' ]
//------------------------------------------------
//2.map()-映射：遍历每一项，转换为新数组(与forEach不同的是，map有返回值，返回的是一个新数组)
//map非常有用！前后端交互时可以用来重新整理数据结构或者修改数据结构，抑或添加新数据
//如果修改了每项的数据，必须return出去
console.log(arrr.map((val, index) => index == '2')) //[ false, false, true ]
console.log(arrr.map(val => val + 2)) //[ 'a2', 'b2', 'c2' ]
console.log(arrr.map(val => val == 'a' ? val + 2 : val + 1)) //[ 'a2', 'b1', 'c1' ]
//如上是箭头函数直接return,如下是带有运算，手动return
let arrr2 = [{
		a: 1,
		b: 2,
		c: 3
	},
	{
		a: 4,
		b: 5,
		c: 6
	},
	{
		a: 7,
		b: 8,
		c: 9
	},
]
let newArrr = arrr2.map((val, index) => {
	val.a = val.a + 1
	val.d = 0
	return val
})
console.log(newArrr) //[ { a: 2, b: 2, c: 3, d: 0},{ a: 5, b: 5, c: 6,d: 0 },{ a: 8, b: 8, c: 9 ,d: 0} ]
//------------------------------------------------
//3.filter()过滤，查找出,查找同find()方法,不同的是filter返回的是数组，而find返回的是数组中的找到的第一项
//filter的回调函数如果返回的是true，这项就被保留返回出去
console.log(arrr.filter(val => val == 'a')) //[ 'a' ]
console.log(arrr.filter((val, index) => index == '2')) //[ 'c' ]
console.log(aaa.filter(val => val == 'a' || val == 'b')) // ["a", "b"]
console.log(arrr.find(val => val == 'a')) //'a'
console.log(arrr.find((val, index) => index == '2')) //'c'
console.log(aaa.find(val => val == 'a' || val == 'b')) //'a'
// 过滤为真的项，有两种方式
arrr.filter(val => val);
arrr.filter(Boolean);
//------------------------------------------------
//4.some()类似与查询,返回的是布尔值，只要有符合条件的一项就返回true
//some()查询的是一个条件，而includes()查询的是某一项本身
console.log(arrr2.some(item => item.b == 2)) //true
console.log(arrr2.some(item => item.b > 2)) //true
console.log(arrr2.some(item => item.b)) //true
//------------------------------------------------
//5.every()也是查询，但是是必须数组里每一项都要符合条件才能返回true
console.log(arrr2.every(item => item.b)) //true
console.log(arrr2.every(item => item.b == 2)) //false
console.log(arrr2.every(item => item.b > 0)) //true
//--------------------------------------------
//6.for..of..循环
for (val of arrr) {
	console.log(val)
}
//a
//b
//c
for (index of arrr.keys()) {
	console.log(index)
}
//0
//1
//2
for (item of arrr.entries()) {
	console.log(item)
}
//[ 0, 'a' ]
//[ 1, 'b' ]
//[ 2, 'c' ]
for ([val, index] of arrr.entries()) {
	console.log(val, index)
}
//0 'a'
//1 'b'
//2 'c'
console.log('*********************************************')
//数组解构赋值
//es5
var a = 1,
	b = 2,
	c = 3;
console.log(a, b, c);

//es6
let [d, e, f] = [3, 4, 5];
console.log(d, e, f);
//定义嵌套数组
let [g, [h, i]] = [4, [5, 6]];
console.log(g, h, i); //4 5 6
//排除某个值不定义
let [j, , k] = [5, 6, 7];
console.log(j, k); //5 7
//一个变量定义多个值
let [l, ...m] = [6, 7, 8];
console.log(l, m); //6 [ 7, 8 ]
//定义默认值
let [n, o, p = 'default', q = 'default'] = [7, 8, 9];
console.log(n, o, p, q); //7 8 9 'default'
//若数组中没有某个值
let [r, s, t] = [7, 8];
console.log(r, s, t); //7 8 undefined
